package Study2;

import java.util.Arrays;

// Comparable 的使用研究
/*
一般情况下，自定义类型进行比较，需要是可以比较的
可以使用 Comparable

* */
                                    // <Student> 泛型
class Student implements Comparable <Student>{
    public String name;
    public int age;
    public int score;


    public Student(String name, int age, int score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override  // 对接口 Comparable 中的  public int compareTo(T o); 抽象方法的重写
    public int compareTo(Student o) {
        if(this.age > o.age) {
            return 1;
        } else if( this.age == o.age) {
            return 0;
        } else {
            return -1;
        }
    }

    @Override // 重写，注释:提示错误，人和编译器都可以读懂的注释
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}


/*
如果想克隆自定义类型 Cloneable ，自定义类型进行比较，需要是可以比较的 Comparable 的使用研究
1，实现接口
public interface Cloneable {
}
空接口 也把他叫做标记接口，其实就是这个意思，只要一个类实现了这个接口，那么就标记这个类，是可以进行 clone(克隆的)
浅拷贝：就是引用类型，面向对象编程所以Java基本上都是浅拷贝，引用同一块地址，
深拷贝：就是不是引用同一块地址，而是，各自有各自的类型的地址
强制类型的 转换 是不会改变数据在内存当中(二进制的存储的)，只是改变了该数据在内存当中取出的显示结果而已。
* */

class Money implements Cloneable{
    double money = 12.5;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone(); // Money 中的money的克隆，返回类型为 Object
    }
}

class Person implements Cloneable {
    public int age = 9;
    Money moneys = new Money();

    @Override // 重写，注释：错误提醒，人和编译器都可以读懂的注释
    protected Object clone() throws CloneNotSupportedException {
        // 对 person 的克隆拷贝
        Person p = (Person)super.clone();// 将 Person 中克隆(clone())的返回类类型，Object类类型强转为 Money类类型
        // 对person.money 的拷贝
        p.moneys = (Money)this.moneys.clone(); // 将 Money 中克隆的返回类型，Object 类类型强转为 Money类类型
        return p; // 注意返回类型是 Object
    }
}

public class Study21 {
    // 对 person 的深拷贝的同时对Person中的 Money 进行了深拷贝
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person1 = (Person)person.clone(); // 把 object的类类型强转为 Person的类类型

        System.out.println(person.moneys.money);
        System.out.println(person1.moneys.money);

        System.out.println("*******修改*********");
        person1.moneys.money = 99.0;
        System.out.println(person.moneys.money);
        System.out.println(person1.moneys.money);

        System.out.println("*********************");

        System.out.println(person.moneys);
        System.out.println(person1.moneys);

        System.out.println("*********************");

        System.out.println(person1);
        System.out.println(person);

    }


    public static void main4(String[] args) throws CloneNotSupportedException { // 异常
//        对 person 的深拷贝的，但是对Person中的 Money 进行了浅拷贝
        Person person = new Person();
        Person person1 = (Person)person.clone();  // 克隆一下,类型的强转把 Object的类型强转为 Person的类型
        System.out.println(person.moneys.money);
        System.out.println(person1.moneys.money);
        System.out.println("**********修改**********");
        person.moneys.money = 99.0;
        System.out.println(person.moneys.money);
        System.out.println(person1.moneys.money);
        System.out.println(person1);
        System.out.println(person);
        System.out.println(person.moneys);
        System.out.println(person1.moneys); // 地址一样 ，

    }


    public static void main3(String[] args) throws CloneNotSupportedException { // 异常
//        对 person 的深拷贝的
        Person person = new Person();
        Person person1 = (Person) person.clone(); // 克隆一下，把 Object的类类型 强转为 Person的类型
        System.out.println(person.age);
        System.out.println(person1.age);
        System.out.println("***************");
        System.out.println(person.moneys.money);
        System.out.println(person1.moneys.money);
        System.out.println("******* 修改 ********");
        person1.age = 99;
        person1.moneys.money = 999;
        System.out.println(person.age);
        System.out.println(person1.age);
        System.out.println(person1);
        System.out.println(person);
        System.out.println("***************");
        System.out.println(person.moneys.money);
        System.out.println(person1.moneys.money);

    }

    public static void main2(String[] args) {
        Student student = new Student("小明",18,79);
        Student student1 = new Student("小红",19,89);
        Student student2 = new Student("小华",18,99);

        Student[] students = new Student[]{  // 该 Student类型的数组
                student,student1,student2
        };

        /*
        if(student > student1) {
            System.out.println("这是无法比较的");
        }
        */

        if(student.compareTo(student1) < 0) {
            System.out.println(student.age+ "<"+ student1.age);

        }
        Arrays.sort(students); // 直接使用是会报错它是无法排序的，我们可以通过接口中的Comparable中的抽象方法, public int compareTo(T o); 抽象方法的重写
        System.out.println(Arrays.toString(students));


    }

    public static void main1(String[] args) {
        int[] array = new int[]{12,5,6,99,55,66};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
    }
}
